package com.jzy.message.util.common;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.ResolveInfo;
import android.graphics.Bitmap;
import android.util.Log;
import android.widget.ImageView;
import android.widget.Toast;

import com.jzy.message.activities.bean.ReturnStatusResultEntity;

import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.Enumeration;
import java.util.List;
import java.util.regex.Pattern;

public class CommUtility {
	public static final int NETWORK_ERROR = 1000;        //http接口调用网络错误
	public static void ChangeImageviewBitmap(final ImageView imageview, Bitmap bitmap) {
		imageview.setImageBitmap(bitmap);

		new Thread(new Runnable() {
			@Override
			public void run() {
				imageview.invalidate();
			}
		});
	}

	public static List<PackageInfo> getAllApps(Context context) {
		PackageManager pManager = context.getPackageManager();
		// 获取手机内所有应用

		return pManager.getInstalledPackages(0);
	}

	public static boolean startApp(Context context, String strAppName) {

		PackageManager pManager = context.getPackageManager();
		List<PackageInfo> apps = getAllApps(context);
		// 获取手机内所有应用
		for (int i = 0; i < apps.size(); i++) {
			PackageInfo pak = (PackageInfo) apps.get(i);
			// 判断是否为目标应用程序
			if (pManager.getApplicationLabel(pak.applicationInfo).toString()
					.equals(strAppName)) {

				Intent intent = new Intent();
				intent = pManager.getLaunchIntentForPackage(pak.applicationInfo.packageName);

				if(intent != null)
				{
					context.startActivity(intent);
					return true;
				}

				return false;
			}
		}

		return false;
	}

	private boolean openApp(Context context, String packageName) {
		PackageManager pManager = context.getPackageManager();
		PackageInfo pi = null;
		try {
			pi = pManager.getPackageInfo(packageName, 0);
		} catch (NameNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return false;
		}
		if(pi == null)
			return false;

		Intent resolveIntent = new Intent(Intent.ACTION_MAIN, null);
		resolveIntent.addCategory(Intent.CATEGORY_LAUNCHER);
		resolveIntent.setPackage(pi.packageName);
		List<ResolveInfo> apps = pManager.queryIntentActivities(resolveIntent, 0);
		ResolveInfo ri = apps.iterator().next();
		if (ri != null) {
			String className = ri.activityInfo.name;
			Intent intent = new Intent(Intent.ACTION_MAIN);
			intent.addCategory(Intent.CATEGORY_LAUNCHER);
			ComponentName cn = new ComponentName(packageName, className);
			intent.setComponent(cn);
			context.startActivity(intent);
			return true;
		}
		return false;
	}
	/*public static String[] getmondayTosunday() {
		// TODO Auto-generated method stub
		String[] result=new String[7];
		Calendar c = Calendar.getInstance();
		int weekday = c.get(7)-1;
		c.add(5,-weekday);
		//c.add(5, 1);
		//result[0]=c.getTime().toString();
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
		for(int i=0;i<7;i++)
		{
			c.add(5,1);
			result[i]=sdf.format(c.getTime()).toString();
		}
		return result;
	}*/
	//当前时间是星期几
	public static String getWeekOfDate() {
		String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
		Calendar cal = Calendar.getInstance();
		Date curDate = new Date(System.currentTimeMillis());
		cal.setTime(curDate);
		int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
		if (w < 0)
			w = 0;
		return weekDays[w];
	}
	public static int getVerCode(Context context,String PackageName) {
		int verCode = -1;
		try {
			verCode = context.getPackageManager().getPackageInfo(
					PackageName, 0).versionCode;
		} catch (NameNotFoundException e) {

		}
		return verCode;
	}

	public static String getVerName(Context context,String PackageName) {
		String verName = "";
		try {
			verName = context.getPackageManager().getPackageInfo(
					PackageName, 0).versionName;
		} catch (NameNotFoundException e) {
			return "";
		}
		return verName;
	}
	public static void showmsg(Context contex,String msg)
	{
		Toast.makeText(contex, msg, Toast.LENGTH_LONG).show();
	}
	//json时间转换
	public static String ConvertJsonDateToCommonDate(String jsonDate)
	{
		try {
			String resultString=jsonDate.substring(6, jsonDate.length()-2);
			Date date = new Date(Long.parseLong(resultString));
			DateFormat format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			return format2.format(date);
			//date.toLocaleString("yyyy-MM-dd HH:mm:ss");
		}
		catch (Exception e)
		{
			return "";
		}
	}
	//html转text
	public static String Html2Text(String inputString) {
		String htmlStr = inputString; //含html标签的字符串
		String textStr ="";
		java.util.regex.Pattern p_script;
		java.util.regex.Matcher m_script;
		java.util.regex.Pattern p_style;
		java.util.regex.Matcher m_style;
		java.util.regex.Pattern p_html;
		java.util.regex.Matcher m_html;

		try {
			String regEx_script = "<[//s]*?script[^>]*?>[//s//S]*?<[//s]*?///[//s]*?script[//s]*?>"; //定义script的正则表达式{或<script[^>]*?>[//s//S]*?<///script> }
			String regEx_style = "<[//s]*?style[^>]*?>[//s//S]*?<[//s]*?///[//s]*?style[//s]*?>"; //定义style的正则表达式{或<style[^>]*?>[//s//S]*?<///style> }
			String regEx_html = "<[^>]+>"; //定义HTML标签的正则表达式

			p_script = Pattern.compile(regEx_script,Pattern.CASE_INSENSITIVE);
			m_script = p_script.matcher(htmlStr);
			htmlStr = m_script.replaceAll(""); //过滤script标签

			p_style = Pattern.compile(regEx_style,Pattern.CASE_INSENSITIVE);
			m_style = p_style.matcher(htmlStr);
			htmlStr = m_style.replaceAll(""); //过滤style标签

			p_html = Pattern.compile(regEx_html,Pattern.CASE_INSENSITIVE);
			m_html = p_html.matcher(htmlStr);
			htmlStr = m_html.replaceAll(""); //过滤html标签
			//替换一些特殊的字符
			htmlStr=htmlStr.replace("&ldquo;", "“");
			htmlStr=htmlStr.replace("&hellip;", "…");
			htmlStr=htmlStr.replace("&mdash;", "-");
			htmlStr=htmlStr.replace("&nbsp;", " ");
			htmlStr=htmlStr.replace("&rdquo;", "”");
			htmlStr=htmlStr.replace("&le;", "<=");
			htmlStr=htmlStr.replace("&ge;", ">=");
			htmlStr=htmlStr.replace("\n", "");
			htmlStr=htmlStr.replace("\r", "");
			htmlStr=htmlStr.replace("&middot;", "·");
			//去掉所有空格
			htmlStr=htmlStr.replaceAll("\\s*", "");
			textStr = htmlStr;

		}catch(Exception e) {
			System.err.println("Html2Text: " + e.getMessage());
		}

		return textStr;//返回文本字符串
	}
	//获取手机ip
	public static String getLocalIpAddress3() {
		try {
			for (Enumeration<NetworkInterface> en = NetworkInterface
					.getNetworkInterfaces(); en.hasMoreElements();) {
				NetworkInterface intf = en.nextElement();
				for (Enumeration<InetAddress> enumIpAddr = intf
						.getInetAddresses(); enumIpAddr.hasMoreElements();) {
					InetAddress inetAddress = enumIpAddr.nextElement();
					if (!inetAddress.isLoopbackAddress()) {
						return inetAddress.getHostAddress().toString();
					}
				}
			}
		} catch (SocketException ex) {
			Log.e("IpAddress", ex.toString());
		}
		return null;
	}
	//将实体类型的数组转换成实体类型的集合
	public static <T> void fromArrayToCollection(T[] a,Collection<T> c){
		for (T t : a) {
			c.add(t);
		}
	}

	/**
	 * 该函数处理http请求返回单个结果的情况
	 *
	 * @param result,请求http返回状态码
	 * @return
	 */
	public static ReturnStatusResultEntity getHttpStatusResult(int result) {
		ReturnStatusResultEntity hre = new ReturnStatusResultEntity();
		hre.httpCode = result;
		switch (result) {
			case 100:// （继续） 请求者应当继续提出请求。 服务器返回此代码表示已收到请求的第一部分，正在等待其余部分。
				hre.isError = true;
				hre.msg = "继续） 请求者应当继续提出请求。 服务器返回此代码表示已收到请求的第一部分，正在等待其余部分。";
				break;
			case 101:// （切换协议） 请求者已要求服务器切换协议，服务器已确认并准备切换。
				hre.isError = true;
				hre.msg = "（切换协议） 请求者已要求服务器切换协议，服务器已确认并准备切换。";
				break;
			case 200:// OK 数据正确返回，需要解析返回的json
				hre.isError = false;
				hre.msg = "数据正确返回，需要解析返回的json";
				break;
			case 201:// （已创建） 请求成功并且服务器创建了新的资源。数据库中没有取到数据
				hre.isError = true;
				hre.msg = "（已创建） 请求成功并且服务器创建了新的资源。数据库中没有取到数据";
				break;
			case 202:// （已接受） 服务器已接受请求，但尚未处理。数据库中没有取到数据
				hre.isError = true;
				hre.msg = "（已接受） 服务器已接受请求，但尚未处理。数据库中没有取到数据";
				break;
			case 203:// （非授权信息） 服务器已成功处理了请求，但返回的信息可能来自另一来源。数据库中没有取到数据
				hre.isError = true;
				hre.msg = "（非授权信息） 服务器已成功处理了请求，但返回的信息可能来自另一来源。数据库中没有取到数据";
				break;
			case 204:// （无内容） 服务器成功处理了请求，但没有返回任何内容。数据库中没有取到数据
				hre.isError = true;
				hre.msg = "（无内容） 服务器成功处理了请求，但没有返回任何内容。数据库中没有取到数据";
				break;
			case 205:// （重置内容） 服务器成功处理了请求，但没有返回任何内容。数据库中没有取到数据
				hre.isError = true;
				hre.msg = "（重置内容） 服务器成功处理了请求，但没有返回任何内容。数据库中没有取到数据";
				break;
			case 206:// （部分内容） 服务器成功处理了部分 GET 请求。数据库中没有取到数据
				hre.isError = true;
				hre.msg = "（部分内容） 服务器成功处理了部分 GET 请求。数据库中没有取到数据";
				break;
			case 300:// （多种选择） 针对请求，服务器可执行多种操作。 服务器可根据请求者 (user agent) 选择一项操作，或提供操作列表供请求者选择。
				hre.isError = true;
				hre.msg = "（多种选择） 针对请求，服务器可执行多种操作。 服务器可根据请求者 (user agent) 选择一项操作，或提供操作列表供请求者选择。";
				break;
			case 301:// （永久移动） 请求的网页已永久移动到新位置。 服务器返回此响应（对 GET 或 HEAD 请求的响应）时，会自动将请求者转到新位置。
				hre.isError = true;
				hre.msg = "（永久移动） 请求的网页已永久移动到新位置。 服务器返回此响应（对 GET 或 HEAD 请求的响应）时，会自动将请求者转到新位置。";
				break;
			case 302:// （临时移动） 服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求。
				hre.isError = true;
				hre.msg = "（临时移动） 服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求。";
				break;
			case 303:// （查看其他位置） 请求者应当对不同的位置使用单独的 GET 请求来检索响应时，服务器返回此代码。
				hre.isError = true;
				hre.msg = "（查看其他位置） 请求者应当对不同的位置使用单独的 GET 请求来检索响应时，服务器返回此代码。";
				break;
			case 304:// （未修改） 自从上次请求后，请求的网页未修改过。 服务器返回此响应时，不会返回网页内容。
				hre.isError = true;
				hre.msg = "（未修改） 自从上次请求后，请求的网页未修改过。 服务器返回此响应时，不会返回网页内容。";
				break;
			case 305:// （使用代理） 请求者只能使用代理访问请求的网页。 如果服务器返回此响应，还表示请求者应使用代理。
				hre.isError = true;
				hre.msg = "（使用代理） 请求者只能使用代理访问请求的网页。 如果服务器返回此响应，还表示请求者应使用代理。";
				break;
			case 307:// （临时重定向） 服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求。
				hre.isError = true;
				hre.msg = "（临时重定向） 服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求。";
				break;
			case 400:// BadRequest 客户端请求的参数不正确，数据检验不过，例如请求用户信息，uid为0，但是uid要求最小为1
				hre.isError = true;
				hre.msg = "客户端请求的参数不正确，数据检验不过";
				break;
			case 401:// （未授权） 请求要求身份验证。 对于需要登录的网页，服务器可能返回此响应。
				hre.isError = true;
				hre.msg = "（未授权） 请求要求身份验证。 对于需要登录的网页，服务器可能返回此响应。";
				break;
			case 403:// Forbidden token到期或者非法，需要重新登录
				hre.isError = true;
				hre.msg = "token到期或者非法，需要重新登录";
				break;
			case 404:// NotFound 客户端请求的URL地址不正确
				hre.isError = true;
				hre.msg = "客户端请求的URL地址不正确";
				break;
			case 405:// （方法禁用） 禁用请求中指定的方法。
				hre.isError = true;
				hre.msg = "（方法禁用） 禁用请求中指定的方法。";
				break;
			case 406:// （不接受） 无法使用请求的内容特性响应请求的网页。
				hre.isError = true;
				hre.msg = "（不接受） 无法使用请求的内容特性响应请求的网页。";
				break;
			case 407:// （需要代理授权） 此状态代码与 401（未授权）类似，但指定请求者应当授权使用代理。
				hre.isError = true;
				hre.msg = "（需要代理授权） 此状态代码与 401（未授权）类似，但指定请求者应当授权使用代理。";
				break;
			case 408:// （请求超时） 服务器等候请求时发生超时。
				hre.isError = true;
				hre.msg = "（请求超时） 服务器等候请求时发生超时。";
				break;
			case 409:// （冲突） 服务器在完成请求时发生冲突。 服务器必须在响应中包含有关冲突的信息。
				hre.isError = true;
				hre.msg = "（冲突） 服务器在完成请求时发生冲突。 服务器必须在响应中包含有关冲突的信息。";
				break;
			case 410:// （已删除） 如果请求的资源已永久删除，服务器就会返回此响应。
				hre.isError = true;
				hre.msg = "（已删除） 如果请求的资源已永久删除，服务器就会返回此响应。";
				break;
			case 411:// （需要有效长度） 服务器不接受不含有效内容长度标头字段的请求。
				hre.isError = true;
				hre.msg = "（需要有效长度） 服务器不接受不含有效内容长度标头字段的请求。";
				break;
			case 412:// （未满足前提条件） 服务器未满足请求者在请求中设置的其中一个前提条件。
				hre.isError = true;
				hre.msg = "（未满足前提条件） 服务器未满足请求者在请求中设置的其中一个前提条件。";
				break;
			case 413:// （请求实体过大） 服务器无法处理请求，因为请求实体过大，超出服务器的处理能力。
				hre.isError = true;
				hre.msg = "（请求实体过大） 服务器无法处理请求，因为请求实体过大，超出服务器的处理能力。";
				break;
			case 414:// （请求的 URI 过长） 请求的 URI（通常为网址）过长，服务器无法处理。
				hre.isError = true;
				hre.msg = "（请求的 URI 过长） 请求的 URI（通常为网址）过长，服务器无法处理。";
				break;
			case 415:// （不支持的媒体类型） 请求的格式不受请求页面的支持。
				hre.isError = true;
				hre.msg = "（不支持的媒体类型） 请求的格式不受请求页面的支持。";
				break;
			case 416:// （请求范围不符合要求） 如果页面无法提供请求的范围，则服务器会返回此状态代码。
				hre.isError = true;
				hre.msg = "（请求范围不符合要求） 如果页面无法提供请求的范围，则服务器会返回此状态代码。";
				break;
			case 417:// （未满足期望值） 服务器未满足”期望”请求标头字段的要求。
				hre.isError = true;
				hre.msg = "（未满足期望值）服务器未满足”期望”请求标头字段的要求。";
				break;
			case 500:// InternalError 服务器出错
				hre.isError = true;
				hre.msg = "服务器繁忙，稍后再试";
				break;
			case 501:// （尚未实施） 服务器不具备完成请求的功能。 例如，服务器无法识别请求方法时可能会返回此代码。
				hre.isError = true;
				hre.msg = "服务器不具备完成请求的功能。";
				break;
			case 502:// （错误网关） 服务器作为网关或代理，从上游服务器收到无效响应。
				hre.isError = true;
				hre.msg = "（错误网关） 服务器作为网关或代理，从上游服务器收到无效响应。";
				break;
			case 503:// （服务不可用） 服务器目前无法使用（由于超载或停机维护）。 通常，这只是暂时状态。
				hre.isError = true;
				hre.msg = "（服务不可用） 服务器目前无法使用（由于超载或停机维护）。";
				break;
			case 504:// （网关超时） 服务器作为网关或代理，但是没有及时从上游服务器收到请求。
				hre.isError = true;
				hre.msg = "（网关超时） 服务器作为网关或代理，但是没有及时从上游服务器收到请求。";
				break;
			case 505:// （HTTP 版本不受支持） 服务器不支持请求中所用的 HTTP 协议版本。
				hre.isError = true;
				hre.msg = "（HTTP 版本不受支持） 服务器不支持请求中所用的 HTTP 协议版本。";
				break;
			case 1000:
				hre.isError = true;
				hre.msg = "请检查您的网络";
				break;
			default:
				hre.isError = true;
				hre.msg = "未知错误";
				break;
		}
		return hre;
	}

	/**
	 * 返回登录时http获取状态
	 *
	 * @param statusCode
	 * @return
	 */
	public static ReturnStatusResultEntity getLoginStatusResult(int statusCode) {
		ReturnStatusResultEntity httpResultEntity = new ReturnStatusResultEntity();
		httpResultEntity.httpCode = statusCode;
		switch (statusCode) {
			case -1:       // 500 internal error
				httpResultEntity.isError = true;
				httpResultEntity.msg = "500 internal error";
				break;
			case 0:       // all success operation
				httpResultEntity.isError = false;
				httpResultEntity.msg = "登录成功";
				break;
			case 1:           // user not exist
				httpResultEntity.isError = true;
				httpResultEntity.msg = "user not exist";
				break;
			case 2:           // wrong password
				httpResultEntity.isError = true;
				httpResultEntity.msg = "wrong password";
				break;
			case 3:       // mobile had been registered
				httpResultEntity.isError = true;
				httpResultEntity.msg = "mobile had been registered";
				break;
			case 4:       // invalid sms
				httpResultEntity.isError = true;
				httpResultEntity.msg = "invalid sms";
				break;
			case 5:       // last sms or auth code is still valid
				httpResultEntity.isError = true;
				httpResultEntity.msg = "last sms or auth code is still valid ";
				break;
			case 6:       // exceed limit for sms request
				httpResultEntity.isError = true;
				httpResultEntity.msg = "exceed limit for sms request";
				break;
			case 7:       // expired sms code
				httpResultEntity.isError = true;
				httpResultEntity.msg = "expired sms code";
				break;
			case 10:       // parameters are null or invalid
				httpResultEntity.isError = true;
				httpResultEntity.msg = "parameters are null or invalid";
				break;
			case 22:       // parameters are null or invalid
				httpResultEntity.isError = true;
				httpResultEntity.msg = "请勿重复提交";
				break;
			default:
				httpResultEntity.isError = true;
				httpResultEntity.msg = "未知错误";
				break;
		}
		return httpResultEntity;
	}
}
